GermanWikipedia - /page/entry.mu

Micron Document

`:top

Die `F33f`_`[Syntax`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Syntax]`_`f der Programmiersprache `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f ist in der `F33f`_`[Java Language Specification`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_Language_Specification]`_`f definiert, ebenso wie die `F33f`_`[Semantik`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Semantik]`_`f von Java.

Dieser Artikel gibt einen Überblick über die Java-Syntax und stellt einige ihrer Besonderheiten heraus. Details sind in den `F33f`_`[Java-Sprachspezifikation von Sun Microsystems`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_Language_Specification]`_`f aufgeführt.

>>Contents

• `F0af`_`[Terminologie`#terminologie]`_`f

• `F0af`_`[Lexikalische Struktur`#lexikalische-struktur]`_`f

• `F0af`_`[Syntax`#syntax]`_`f

• `F0af`_`[Datentypen`#datentypen]`_`f

• `F0af`_`[Reservierte Wörter`#reservierte-w-rter]`_`f

• `F0af`_`[Pakete, Namen, Klassen, Schnittstellen`#pakete-namen-klassen-schnittstellen]`_`f

• `F0af`_`[Methoden`#methoden]`_`f

• `F0af`_`[Attribute`#attribute]`_`f

• `F0af`_`[Felder`#felder]`_`f

• `F0af`_`[Anweisungen und Kontrollstrukturen`#anweisungen-und-kontrollstrukturen]`_`f

• `F0af`_`[Ausdrücke`#ausdr-cke]`_`f

• `F0af`_`[Kommentare`#kommentare]`_`f

• `F0af`_`[Generische Programmierung`#generische-programmierung]`_`f

• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f

-─

>>Terminologie

Da Java eine Programmiersprache ist, zu deren Beschreibung überwiegend englischsprachige Begriffe benutzt werden, aber dennoch in der Literatur ebenfalls eingedeutschte Übersetzungen bestimmter Bestandteile verwendet werden, soll an dieser Stelle über die `F33f`_`[Mehrdeutigkeit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Disambiguierung]`_`f aufgeklärt und ebenfalls die von diesem Artikel verwendeten Ausdrücke festgelegt werden, damit eine Verwechslung ausgeschlossen werden kann. Im Folgenden werden die in diesem Artikel verwendeten Begriffe und ihre englischen oder deutschen Entsprechungen aufgeführt.

`!Ausdruck`!

(engl. `*Expression`*) Unter einem `F33f`_`[Ausdruck`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ausdruck_(Programmierung)]`_`f wird ein beliebig komplexes Sprachkonstrukt verstanden, dessen Auswertung einen einzigen wohl definierten Wert ergibt. Im einfachsten Fall ist ein Ausdruck eine Konstante, wie z. B. das Schlüsselwort `*true`* oder auch eine Zahl (z. B. `*1`* oder `*0x7fff`*). Komplexere Ausdrücke sind Vergleiche oder Berechnungen mit mehreren Variablen und Konstanten. Innerhalb der Grammatikbeschreibungen wird hier häufig noch nach verschiedenen Arten von Ausdrücken (z. B. numerisch, literal etc.) unterschieden, was hier nicht der Fall sein soll.

`!Anweisung`!

(engl. `*Statement`*, `*Instruction`* oder `*Command`*; auch `*Befehl`* genannt) Eine `F33f`_`[Anweisung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anweisung_(Programmierung)]`_`f bezeichnet in Java, wie auch in vielen anderen imperativen Programmiersprachen, eine einzelne Vorschrift, die im Rahmen der Abarbeitung des Programms auszuführen ist. Dazu zählen die Deklaration von Variablen, durch Semikolon abgeschlossene Ausdrücke, Kontrollstrukturen, Anweisungsblöcke, Sprunganweisungen, Synchronisierungsblöcke, Rückgaben von Werten und das Auslösen von Ausnahmen.

`!Anweisungsblock`!

(engl. `*Statement Block`*) Ein Anweisungsblock dient dazu, mehrere Anweisungen zu gruppieren. Dadurch können mehrere Anweisungen wie eine einzelne Anweisung interpretiert werden, was von einigen Sprachkonstrukten vorausgesetzt wird – wie etwa von den Kontrollstrukturen.

>>Lexikalische Struktur

Java-Programme werden in `F33f`_`[Unicode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unicode]`_`f geschrieben. Im Gegensatz zu anderen Sprachen können Bezeichner (englisch `*Identifier`*) von Klassen, Methoden, Variablen usw. nicht nur die Buchstaben des lateinischen Alphabets und Ziffern enthalten, sondern auch Zeichen aus anderen Alphabeten, wie z. B. deutsche Umlaute oder chinesische Schriftzeichen.

Sämtliche Schlüsselwörter in Java werden klein geschrieben, z. B. „`B100`F9d9class`f`b“ oder „`B100`F9d9if`f`b“.

Buchstabensymbole (englisch `*literals`*) sind in Java die kleinstmöglichen Ausdrücke für Zahlen, einzelne Zeichen, Zeichenketten (`*Strings`*), logische Werte (`B100`F9d9true`f`b oder `B100`F9d9false`f`b) und das spezielle Wort `B100`F9d9null`f`b.

Trennzeichen (englisch `*separators`*) sind verschiedene Arten von Klammern sowie Komma, Punkt und Semikolon.

Java kennt die in Programmiersprachen üblichen `F33f`_`[logischen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Logischer_Operator]`_`f, `F33f`_`[Vergleichs-`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Vergleichsoperator]`_`f und `F33f`_`[mathematischen Operatoren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Operator_(Mathematik)]`_`f. Die Syntax orientiert sich dabei an der `F33f`_`[Programmiersprache C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f. So dient zum Beispiel das einfache Gleichheitszeichen „`B100`F9d9=`f`b“ als Zuweisungsoperator, während für Vergleiche das doppelte Gleichheitszeichen „`B100`F9d9==`f`b“ verwendet wird.

Leerzeichen, Zeilenenden und Kommentare können an beliebigen Stellen zwischen den Bezeichnern, Schlüsselwörtern, Buchstabensymbolen, Trennzeichen und Operatoren eingefügt werden.

>>Syntax

>>>Datentypen

Java kennt zwei `F33f`_`[Datentyparten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datentyp]`_`f: primitiver Datentyp und `F33f`_`[Referenzen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Referenz_(Programmierung)]`_`f auf Objekte. Die primitiven Datentypen sind ein Grund, weshalb Java strenggenommen keine reine objektorientierte Sprache ist.

>>>>Primitive Datentypen

Es gibt acht primitive Datentypen. Sie haben unterschiedliche Größen und Eigenschaften und werden zum Berechnen und Speichern diskreter Zahlenwerte benutzt. Alle diese Datentypen verfügen über eine fest definierte Größe, die für alle Plattformen gleich ist. Für jeden Typ existiert eine entsprechende `F33f`_`[Wrapper`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Adapter_(Entwurfsmuster)]`_`f-Klasse, um auch diese als echte Objekte behandeln zu können.

|---|---|---|---|---|

| int | 32 Bit | java.lang.Integer | −2.147.483.648 … +2.147.483.647 | Zweierkomplement-Wert |

Gibt die Größe des Wertebereichs an. Der tatsächliche Speicherbedarf ist abhängig von Plattform und Implementierung der Java Virtual Machine.

>>>>Typumwandlung

Die Hierarchie für das `F33f`_`[Umwandeln`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Typumwandlung]`_`f (`*type casting`*) der primitiven Datentypen lässt sich aus der oberen Tabelle erahnen. Die numerischen Datentypen lassen sich verlustfrei in den nächstgrößeren Datentyp umrechnen, jedoch nicht umgekehrt. So kann ein „`B100`F9d9int`f`b“ implizit, also ohne speziellen Operator, in ein „`B100`F9d9long`f`b“ umgewandelt werden, jedoch nicht umgekehrt.

`B100`F9d9int i = 12345;`f`b

`B100`F9d9long l = i;`f`b

Um jedoch in umgekehrter Richtung beispielsweise einen „`B100`F9d9long`f`b“ in ein „`B100`F9d9int`f`b“ umzuwandeln, muss der Typumwandlungsoperator verwendet werden. Dabei können auch Informationen verloren gehen.

`B100`F9d9long l = 12345678901L;`f`b

`B100`F9d9int i = (int) l;`f`b

Hier tritt ein Informationsverlust auf: „`B100`F9d9i`f`b“ hat nach der Zuweisung den Wert −539222987, weil die höherwertigen Bytes abgeschnitten werden.

Der primitive Datentyp „`B100`F9d9boolean`f`b“ kann in keinen anderen Datentyp umgewandelt werden. Zeichen vom Typ „`B100`F9d9char`f`b“ können implizit in jeden ganzzahligen Typ ab „`B100`F9d9int`f`b“ umgewandelt werden. Dies hängt insbesondere damit zusammen, dass „`B100`F9d9char`f`b“ den einzigen in Java bekannten vorzeichenlosen Datentyp darstellt. Damit ist eine verlustfreie Konvertierung nach „`B100`F9d9short`f`b“ ab dem Wert 32768 nicht mehr möglich.

>>>>Referenzen

Alle Objekte und `F33f`_`[Felder`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Feld_(Java)]`_`f liegen im `F33f`_`[Heap`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dynamischer_Speicher]`_`f-Speicher und werden deshalb über eine Adresse referenziert. Der Objektzugriff in Java ist über `F33f`_`[Referenzen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Referenz_(Programmierung)]`_`f implementiert, welche den aus C/C++ bekannten Zeigern ähneln.`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f] Die Sprachdefinition (Java Language Specification) bezeichnet sie als „Reference Values“, um deutlich zu machen, dass sie durch `F33f`_`[Call-by-Value`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wertparameter]`_`f übergeben werden.`:cite-ref-sun-reference-value-2-0[`F5bf`_`[2`#cite-note-sun-reference-value-2]`_`f] In Java gibt es keine direkte Möglichkeit, die Speicheradresse einer Referenz anzuzeigen oder diese zu modifizieren, wodurch sogenannte Zeigerarithmetik in Java ausgeschlossen wird.

`B100`F9d9Object a = new Object(); // a referenziert das gerade neu erstellte Objekt`f`b

`B100`F9d9Object b = a; // b referenziert dasselbe Objekt wie a`f`b

`B100`F9d9a = null; // a referenziert kein Objekt mehr, enthält somit die reservierte Adresse null.`f`b

Hierbei gilt es festzuhalten, dass auch Zeichenketten (Klasse `B100`F9d9String`f`b) Referenztypen darstellen und daher inhaltlich stets über die Methode `B100`F9d9equals()`f`b zu vergleichen sind („`B100`F9d9==`f`b“ kontrolliert nur die Referenzen, d. h. Speicheradressen). Dies steht im Gegensatz zu Programmiersprachen wie C++ und `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f, welche die vollständige Operatorenüberladung unterstützen und bei `B100`F9d9"hallo"=="hallo"`f`b Inhaltsvergleiche durchführen.

>>>Reservierte Wörter

`B100`F9d9const`f`b und `B100`F9d9`F33f`_`[goto`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sprunganweisung]`_`f`f`b sind zwar reserviert, aber ohne Funktion, also keine Schlüsselwörter im eigentlichen Sinn. Sie dienen lediglich dem Compiler zur Ausgabe sinnvoller Fehlermeldungen für Umsteiger von C++ oder C.

`B100`F9d9true`f`b, `B100`F9d9false`f`b und `B100`F9d9null`f`b sind Literale, jedoch ebenfalls eigentlich keine Schlüsselwörter im engeren Sinn.

Mit `B100`F9d9assert`f`b werden `F33f`_`[Assertions`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Assertion_(Informatik)]`_`f realisiert.

`B100`F9d9private`f`b, `B100`F9d9protected`f`b und `B100`F9d9public`f`b sind `F33f`_`[Zugriffsmodifikatoren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zugriffsmodifikator]`_`f (`*access modifier`*):

|---|---|---|---|---|

| protected | Ja | Ja | Ja | Nein |

| public | Ja | Ja | Ja | Ja |

`:cite-note-3`!1.`! Um inneren Klassen den Zugriff auf private Methoden und Eigenschaften dennoch zu ermöglichen, werden vom Compiler statische, paket-private Methoden erstellt, die den Aufruf, das Setzen oder das Auslesen emulieren. Diese Methoden tragen den Namen `B100`F9d9access$xxx`f`b, wobei `B100`F9d9xxx`f`b für eine fortlaufende Nummer steht.

`:cite-note-4`!2.`! Häufig auch als „package private“ bezeichnet, obwohl es diesen Zugriffsmodifikator nicht gibt.

Private Methoden sind von der Polymorphie ausgenommen, d. h. die Definition einer Methode derselben Signatur in einer Subklasse gilt nicht als `*Überschreiben`* (sondern als `*Verbergen`*).

`B100`F9d9static`f`b kennzeichnet Implementierungen, die ohne eine Objektreferenz verwendbar sind. Das Schlüsselwort wird bei der Deklaration von Feldern, Methoden und inneren Klassen verwendet. Felder, Methoden und Klassen, die mittels `B100`F9d9static`f`b gekennzeichnet sind, werden im Kontext der `F33f`_`[Klasse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Klasse_(Programmierung)]`_`f verwendbar und sind an kein `F33f`_`[Objekt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objekt_(Programmierung)]`_`f gekoppelt.

`B100`F9d9abstract`f`b kann vor Klassen und `F33f`_`[Methoden`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Methode_(Programmierung)]`_`f stehen. Abstrakte Methoden verfügen über keine Implementierung und müssen in abgeleiteten Klassen überschrieben werden. Klassen, die abstrakte Methoden enthalten, müssen selbst als abstrakt deklariert werden. Abstrakte Klassen können nicht instanziiert werden, auch wenn sie vollständig implementiert sind, wie z. B. im Fall der EventListener-Adapterklassen des `F33f`_`[Swing`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Swing_(Java)]`_`f-Frameworks.

`B100`F9d9final`f`b kann vor `F33f`_`[Variablen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Variable_(Programmierung)]`_`f, Feldern, Methoden und Klassen stehen und erzwingt Unveränderlichkeit. Bei Variablen und Membervariablen ihre Konstanz, bei Methoden die Unmöglichkeit, sie in abgeleiteten Klassen zu überschreiben und schließlich bei Klassen, dass von ihnen keine weiteren Ableitungen erfolgen können. Einer finalen Variable wird einmalig ein Wert zugewiesen, der nachträglich nicht mehr verändert werden kann. Eine finale Variable muss nicht in der Deklaration initialisiert werden, sondern kann auch erst in folgenden, alternativen Anweisungen einmalig belegt werden:

`B100`F9d9public int calcFinal(int a) {`f`b

`B100`F9d9 final int b; // hier findet noch keine Zuweisung statt`f`b

`B100`F9d9 switch (a) {`f`b

`B100`F9d9 case 1:`f`b

`B100`F9d9 b = 7;`f`b

`B100`F9d9 break;`f`b

`B100`F9d9 case 2:`f`b

`B100`F9d9 b = 3;`f`b

`B100`F9d9 break;`f`b

`B100`F9d9 default:`f`b

`B100`F9d9 b = 1;`f`b

`B100`F9d9 break;`f`b

`B100`F9d9 }`f`b

`B100`F9d9 return b;`f`b

`B100`F9d9}`f`b

Zugriffe auf finale Variablen, deren Wert dem Compiler bekannt ist, dürfen vom Compiler durch den Wert der Variable ersetzt werden. Aufrufe finaler Methoden dürfen vom Compiler durch eingebundenen Code (Inlining) ersetzt werden. Private Methoden sind automatisch final.

`B100`F9d9native`f`b kann nur vor Methoden stehen und bedeutet, dass die Implementierung der betreffenden Methode nicht in Java, sondern einer anderen Programmiersprache geschrieben wurde, und von der virtuellen Maschine über eine `F33f`_`[Laufzeitbibliothek`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Laufzeitbibliothek]`_`f eingebunden werden muss.

`B100`F9d9strictfp`f`b kennzeichnet Klassen und Methoden, deren enthaltene Gleitkommaoperationen streng nach `F33f`_`[IEEE 754`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IEEE_754]`_`f ablaufen müssen.

`B100`F9d9package`f`b deklariert die Paketzugehörigkeit eines komplexen Datentyps. Die Namensgebung eines Pakets sollte eindeutig sein und orientiert sich meist an der `F33f`_`[Internet-Domain`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Domain_(Internet)]`_`f des Eigentümers oder Erstellers.

`B100`F9d9import`f`b importiert Symbole (vorher nur Typen, ab Java 5 auch statische Member von Klassen), so dass sie ohne voll qualifizierten Namen verwendet werden können. Der Import kann hierbei über das Wildcard `B100`F9d9*`f`b auf komplette Pakete ausgedehnt werden.

`B100`F9d9boolean`f`b, `B100`F9d9char`f`b, `B100`F9d9byte`f`b, `B100`F9d9short`f`b, `B100`F9d9int`f`b, `B100`F9d9long`f`b, `B100`F9d9float`f`b und `B100`F9d9double`f`b sind Typen. `B100`F9d9void`f`b ist der Nichtstyp, notwendig, um Methoden ohne Rückgabewerte zu kennzeichnen. Für die primitiven Typen: siehe oben.

`B100`F9d9class`f`b, `B100`F9d9interface`f`b, `B100`F9d9enum`f`b und `B100`F9d9@interface`f`b dienen zur Deklaration eigener Typen: Klassen, Interfaces (Schnittstellen für Klassen), Enums (`F33f`_`[Aufzählungstyp`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aufzählungstyp]`_`f für typsichere Aufzählung, englisch `*typesafe enumeration`*) und Annotations für Metadaten. `B100`F9d9enum`f`b und `B100`F9d9@interface`f`b sind mit Java 5 in die Sprache aufgenommen worden.

`B100`F9d9try`f`b, `B100`F9d9catch`f`b, `B100`F9d9finally`f`b, `B100`F9d9throw`f`b, `B100`F9d9throws`f`b beziehen sich auf die `F33f`_`[Ausnahmebehandlung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ausnahmebehandlung]`_`f (englisch `*exception handling`*). Mit `B100`F9d9throw`f`b wird eine Ausnahme ausgelöst. Alle eventuell ausgelösten Ausnahmen einer Methode, die nicht von `B100`F9d9RuntimeException`f`b oder `B100`F9d9Error`f`b abstammen, müssen mit `B100`F9d9throws`f`b in der Deklaration der Methode angegeben werden. Es handelt sich also um so genannte `*checked exceptions`*. `B100`F9d9try`f`b umschließt einen Block, in dem eventuell eine Ausnahme auftreten könnte. `B100`F9d9catch`f`b fängt nach einem `B100`F9d9try`f`b-Block die dort aufgetretene Ausnahme ab, `B100`F9d9finally`f`b wird an einen `B100`F9d9try`f`b- oder `B100`F9d9catch`f`b-Block für Aufräumarbeiten wie das Schließen von Dateien angehängt.

`B100`F9d9extends`f`b und `B100`F9d9implements`f`b dienen der Vererbung: `B100`F9d9extends`f`b der genetischen Erweiterungsvererbung von Klasse zu Klasse oder Interface zu Interface und `B100`F9d9implements`f`b der Implementierungsvererbung von Interface zu Klasse. Außerdem wird `B100`F9d9extends`f`b bei Generics für Typerweiterung verwendet.

`B100`F9d9super`f`b und `B100`F9d9this`f`b beziehen sich im Objekt-Kontext auf das aktuelle Objekt in seinem tatsächlichen Morph (`B100`F9d9this`f`b) oder im Morph der Superklasse (`B100`F9d9super`f`b). `B100`F9d9this`f`b wird verwendet, um in Konstruktoren überladene Konstruktoren aufzurufen und um in Membern auf verdeckte Member äußerer Strukturen zu verweisen. `B100`F9d9super`f`b wird in Konstruktoren zum Aufruf des Superklassenkonstruktors und in überschreibenden Methoden zum Aufruf der überschriebenen Methode verwendet. Außerdem wird `B100`F9d9super`f`b bei Generics für Typeingrenzung verwendet.

`B100`F9d9new`f`b reserviert Speicher für neue Objekte (inklusive Arrays) auf dem `F33f`_`[Heap`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dynamischer_Speicher]`_`f.

`B100`F9d9if`f`b, `B100`F9d9else`f`b, `B100`F9d9switch`f`b, `B100`F9d9case`f`b, `B100`F9d9default`f`b, `B100`F9d9while`f`b, `B100`F9d9do`f`b, `B100`F9d9for`f`b, `B100`F9d9break`f`b, `B100`F9d9continue`f`b dienen der Bedingungsprüfung und Schleifensteuerung und bedienen sich einer imperativen Syntax.

`B100`F9d9return`f`b liefert Werte aus einer Methode an die aufrufende Methode zurück.

`B100`F9d9volatile`f`b ist ein Modifikator für nicht-lokale Variablen und verbietet dem `F33f`_`[JIT-Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Just-in-time-Kompilierung]`_`f Registeroptimierungen auf diese Variable, weil mehrere Threads sie gleichzeitig verwenden könnten (insbesondere im Kontext nativer Methoden).

`B100`F9d9synchronized`f`b kennzeichnet einen `F33f`_`[kritischen Abschnitt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kritischer_Abschnitt]`_`f im Quelltext, der nur von einem `F33f`_`[Thread`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Thread_(Informatik)]`_`f gleichzeitig ausgeführt werden darf. Ein `F33f`_`[Monitor`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Monitor_(Informatik)]`_`f sperrt den Abschnitt, sobald ihn ein Thread betritt. Versucht ein anderer Thread den gesperrten Abschnitt zu betreten, blockiert dieser Thread so lange, bis der Monitor den Abschnitt freigibt. Jedes beliebige Java-Objekt kann als Monitor verwendet werden. Ist eine Methode mit `B100`F9d9synchronized`f`b gekennzeichnet, wird automatisch das Objekt bzw. bei statischen Methoden das Klassenobjekt als Monitor verwendet.

`B100`F9d9transient`f`b kennzeichnet nicht-persistente Variablen, die nicht serialisiert werden dürfen.

`B100`F9d9instanceof`f`b ist ein Java-Operator, der prüft, ob ein Objekt Exemplar eines angegebenen Typs oder Subtyps ist.

>>>Pakete, Namen, Klassen, Schnittstellen

Ein Java-Paket (englisch `*package`*) enthält mehrere Klassen, Schnittstellen und Ausnahmen und bildet einen eigenen `F33f`_`[Namensraum`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Namensraum]`_`f.

Java-Quelltext ist auf mehrere Übersetzungseinheiten (englisch `*compilation units`*) aufgeteilt, von denen jede in einer eigenen Datei abgelegt ist. Jede einzelne Übersetzungseinheit definiert als erstes das Paket, dem sie angehört, importiert dann mehrere Klassen oder Schnittstellen aus anderen Paketen, und definiert schließlich eine oder mehrere Klassen und Schnittstellen.

Java unterscheidet einfache Namen, die nur aus einem Bezeichner bestehen, und vollqualifizierte Namen, die aus einer Reihe von Bezeichnern bestehen, die durch Punkte getrennt sind. Die einfachen Namen sind nur ein Hilfsmittel, das dem Programmierer Tipparbeit ersparen und die Lesbarkeit des Programms erhöhen soll. Der Compiler übersetzt sie immer in vollqualifizierte Namen.

Das folgende Beispiel zeigt ein `F33f`_`[Hallo-Welt-Programm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hallo-Welt-Programm]`_`f in Java.

`B100`F9d9package org.wikipedia;`f`b

`B100`F9d9`f`b

`B100`F9d9import static java.lang.System.out;`f`b

`B100`F9d9`f`b

`B100`F9d9public class HalloWelt {`f`b

`B100`F9d9`f`b

`B100`F9d9 public static void main(String[] arguments) {`f`b

`B100`F9d9 out.println("Hallo Welt.");`f`b

`B100`F9d9 }`f`b

`B100`F9d9`f`b

`B100`F9d9}`f`b

In diesem Beispiel wird eine Klasse „`B100`F9d9HalloWelt`f`b“ definiert, die dem Paket „`B100`F9d9org.wikipedia`f`b“ angehört. Per Konvention orientieren sich die Paketnamen in Java an den `F33f`_`[Internet-Domänen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Domäne_(Internet)]`_`f ihrer Entwickler, in diesem Fall also „`B100`F9d9org.wikipedia`f`b“ für die Domäne „`B100`F9d9wikipedia.org`f`b“. Die Richtung des Namens wird umgedreht, weil bei Internet-Domänen der Name der äußersten Einheit hinten steht, während er in Java vorne steht. Das Paket „`B100`F9d9org.wikipedia`f`b“ befindet sich also „innerhalb“ des Pakets „`B100`F9d9org`f`b“.

Eine Import-Anweisung definiert einen einfachen Namen für einen vollqualifizierten Namen. So definiert z. B. die Anweisung „`B100`F9d9import java.io.File`f`b“ den einfachen Namen „`B100`F9d9File`f`b“ für die Klasse, die mit vollem Namen „`B100`F9d9java.io.File`f`b“ heißt. Neben Imports von Klassen und Schnittstellen können seit Java Version 5 auch statische Felder oder Methoden von Klassen importiert werden. Ein solcher „statischer Import“ wird durch das zusätzliche Schlüsselwort „`B100`F9d9static`f`b“ festgelegt. Im obigen Beispiel wird das statische Feld „`B100`F9d9out`f`b“ der Klasse „`B100`F9d9java.lang.System`f`b“ importiert und anschließend unter dem kurzen Namen „`B100`F9d9out`f`b“ verwendet.

Das wichtigste Konstrukt der Programmiersprache Java ist, da sie eine objektorientierte Sprache ist, die `F33f`_`[Klasse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Klasse_(objektorientierte_Programmierung)]`_`f. Die `F33f`_`[Deklaration`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deklaration_(Programmierung)]`_`f einer Klasse wird mit dem Schlüsselwort „`B100`F9d9class`f`b“ eingeleitet. Anschließend folgt der Name der Klasse und dann werden – in geschweiften Klammern – die Felder und Methoden der Klasse definiert.

Eine Besonderheit von Java stellt die Schnittstelle dar. Eine solche Schnittstelle besteht nur aus Methoden-Deklarationen, deren Implementierung erst von den Klassen festgelegt werden, die sie „implementieren“. Die Deklaration einer Schnittstelle sieht ähnlich aus wie die Deklaration einer Klasse, sie wird jedoch mit dem Schlüsselwort „`B100`F9d9interface`f`b“ eingeleitet.

`B100`F9d9package org.wikipedia;`f`b

`B100`F9d9`f`b

`B100`F9d9public interface Article {`f`b

`B100`F9d9`f`b

`B100`F9d9 String getName();`f`b

`B100`F9d9`f`b

`B100`F9d9 void setContent(String aContent);`f`b

`B100`F9d9`f`b

`B100`F9d9}`f`b

Da alle Methoden einer Schnittstelle abstrakt sind, kann das Schlüsselwort „`B100`F9d9abstract`f`b“ bei den einzelnen Methoden entfallen. Ebenso kann das Schlüsselwort „`B100`F9d9public`f`b“ vor den einzelnen Methoden entfallen, weil Methoden einer Schnittstelle immer öffentlich sind.

Ab Java 8 kommt die Möglichkeit hinzu, in Schnittstellen statische Methoden sowie „`B100`F9d9default`f`b“-Methoden zu definieren. Darüber hinaus können Schnittstellen mit der Annotation „`B100`F9d9@FunctionalInterface`f`b“ versehen werden, um anzuzeigen, dass es sich bei ihr um eine funktionale Schnittstelle handelt. Eine solche ist dadurch definiert, dass sie genau eine abstrakte Methode deklariert; die Annotation ist nicht dafür erforderlich. Funktionale Schnittstellen können kurz und bündig durch Lambda-Ausdrücke oder Methodenreferenzen implementiert werden.

>>>Methoden

Das eigentliche Verhalten eines Objekts wird in Methoden definiert. Die `F33f`_`[Signatur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Signatur_(Programmierung)]`_`f einer Methode besteht aus ihrem Namen und den Typen ihrer Parameter. Außerdem hat jede Methode einen bestimmten Rückgabetyp oder „`B100`F9d9void`f`b“, wenn sie nichts zurückgibt, und kann eine Reihe von Ausnahmen in einer so genannten „`B100`F9d9throws`f`b“-Klausel definieren.

`*Beispiel einer konkreten Methode:`*

`B100`F9d9public double summe(double a, double b) throws NotANumberException {`f`b

`B100`F9d9 if (Double.isNaN(a) || Double.isNaN(b)) {`f`b

`B100`F9d9 throw new NotANumberException();`f`b

`B100`F9d9 }`f`b

`B100`F9d9 return a + b;`f`b

`B100`F9d9}`f`b

Diese Methode erwartet zwei doppelt genaue `F33f`_`[Gleitkommazahlen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Gleitkommazahl]`_`f als Parameter und gibt die Summe der beiden ebenfalls als Gleitkommazahl zurück. Falls eine der beiden Zahlen keine gültige Gleitkommazahl ist, wirft die Methode eine Ausnahme namens „`B100`F9d9NotANumberException`f`b“.

`*Beispiel einer abstrakten Methode:`*

`B100`F9d9public abstract double summe(double a, double b) throws NotANumberException;`f`b

>>>Attribute

`F33f`_`[Attribute`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Attribut_(UML)]`_`f sind Variablen, die zu einem Objekt gehören. Sie sind durch einen Typ und einen Namen definiert und können wahlweise bereits wenn das Objekt erzeugt wird initialisiert werden.

`*Beispiel einer Variablendeklaration ohne Initialisierung:`*

`B100`F9d9private int x;`f`b

Klassenvariablen werden als statische Attribute deklariert. Diese Attribute existieren nicht einmal pro Objekt, sondern nur einmal pro Klasse. Das Schlüsselwort „`B100`F9d9final`f`b“ verhindert, dass eine Variable nach ihrer Initialisierung ihren Wert ändert. Es wird zum Beispiel verwendet, um Konstanten zu definieren.

`*Beispiel einer statischen und finalen Klassenvariablendeklaration mit Initialisierung:`*

`B100`F9d9private static final int X = 2;`f`b

>>>Felder

In der `F33f`_`[Programmiersprache Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f ist ein `F33f`_`[Feld`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Feld_(Datentyp)]`_`f (englisch `*Array`*) ein eigenständiges Objekt. Dieses kann Daten eines bei der Deklaration festgelegten Typs aufnehmen. Der Speicher wird erst bei der Initialisierung des Feldes belegt. Dazu muss eine Länge (englisch `*Size`*) angegeben werden, die beschreibt wie viele Elemente eines Typs das Feld besitzen soll. Die Größe eines Arrays ist fix und kann nach der Instanziierung nicht mehr geändert werden. In Java wird ein Feld immer mit einem positiven Integer indiziert. Dadurch beschränkt sich die mögliche Länge eines Arrays auf 0 bis 231 − 1.

Die einzelnen Elemente eines Feldes werden – analog zu den Attributen anderer Objekte – bei der Instanziierung des Feldes mit dem Nullwert des jeweiligen Feld-Grundtyps initialisiert. Für Felder von numerischen Primitivtypen ist dies 0 bzw. 0.0, für ein Feld mit dem Grundtyp boolean ist es der Wert `B100`F9d9false`f`b, für Felder von Objektreferenzen die leere Referenz `B100`F9d9null`f`b. Bei der Erzeugung eines Feldes von Objektreferenzen werden also außer dem Feld selbst noch keine Objekte erzeugt.

Echte mehrdimensionale Felder gibt es in Java nicht. Dennoch ist es möglich, mehrdimensionale Felder zu erstellen, indem Felder in Feldern verschachtelt werden. Im Falle eines zweidimensionalen Feldes wird hier zunächst ein Feld erstellt, welches Referenzen auf Felder des gewünschten Typs aufnehmen kann. Anschließend wird jedem Platz dieses Feldes eine Referenz auf ein eindimensionales Feld des gewünschten Grundtyps zugewiesen.

>>>>Eindimensionales Feld

`!Deklaration`!

`B100`F9d9<Datentyp>[] <Variablenbezeichner>; // Deklaration`f`b

`B100`F9d9<Datentyp> <Variablenbezeichner>[]; // Alternative Deklaration (seltener verwendet)`f`b

Bei der Deklaration wird der Datentyp des Feldes festgelegt. Dabei wird jedoch kein Feld allokiert, sondern wie bei allen anderen Objekten nur eine Referenz eines Types definiert, der ein Feld zugewiesen werden kann.

`!Instanziierung`!

`B100`F9d9<Variablenbezeichner> = new <Datentyp>[<Anzahl>]; // Instanziierung eines eindimensionalen Feldes`f`b

Bei der `F33f`_`[Instanziierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objekt_(Programmierung)]`_`f eines eindimensionalen Feldes muss sowohl dessen Datentyp als auch die Anzahl der Elemente bekannt sein. Wie bereits am Anfang angemerkt ist die Länge eines Feldes auf nichtnegative ganzzahlige Werte beschränkt. Das Schlüsselwort `B100`F9d9new`f`b hat hier dieselbe Bedeutung wie bei allen anderen Objekten und legt eine Instanz des Typs an. Dabei wird der benötigte Speicher für das Objekt als auch für dessen Elemente reserviert. Im Gegensatz zu anderen Objekten verfügen Felder aber über keine Konstruktoren und es ist nicht möglich, durch explizite Ableitung Subtypen eines Feldtyps zu bilden.

`!Beispiel eines eindimensionalen Feldes des Typs `*int`* der Länge 3`!

`B100`F9d9int[] feld = new int[3]; // auf der linken Seite wird die Objektreferenz deklariert`f`b

`B100`F9d9 // auf der rechten Seite wird das Feld initialisiert`f`b

Die Deklaration und Instanziierung muss nicht getrennt voneinander erfolgen, sondern kann wie üblich auch als eine Anweisung geschrieben werden. Beim Zugriff auf die Elemente ist zu beachten, dass Java mit dem Index 0 anfängt zu zählen. So wird in diesem Beispiel mit Index 0 auf das erste Element zugegriffen und mit Index 2 auf das letzte Element.

`B100`F9d9int[] feld = {1,2,3}`f`b

ist eine Verkürzung von

`B100`F9d9int[] feld = new int[3];`f`b

`B100`F9d9feld[0]=1;`f`b

`B100`F9d9feld[1]=2;`f`b

`B100`F9d9feld[2]=3;`f`b

`!Auslesen von Werten`!

`B100`F9d9int a = feld[0]; // das Auslesen erfolgt durch Angabe des Index`f`b

`B100`F9d9objekt.methode(feld[1]); // Einzelwerte eines Feldes können wie Variablen des gleichen Typs verwendet werden`f`b

`B100`F9d9int b = feld[3]; // würde in diesem Beispiel eine IndexOutOfBoundsException auslösen, da es kein 4. Element gibt`f`b

`!Zuweisung von Werten`!

`B100`F9d9feld[0] = 5; // Java ist "nullbasiert"`f`b

`B100`F9d9feld[1] = (int) 2.7; // bei Zuweisungen muss wie bei normalen Variablen der Typ angepasst werden`f`b

`B100`F9d9feld[2] = 0; // die Indexierung läuft immer bis n-1`f`b

`! Länge eines Feldes`! Viele Algorithmen benötigen die Länge eines Feldes, etwa um alle Einträge abzuarbeiten. Die Länge eines Feldes ist zur Laufzeit bekannt und kann über die Objektvariable `B100`F9d9length`f`b abgefragt werden, die selbst vom Typ `B100`F9d9int`f`b ist. Diese Variable ist stets konstant und kann nicht geändert werden. Eine Zuweisung eines anderen Wertes ist also nicht möglich.

`B100`F9d9int len = feld.length; // Liest die Länge des Feldes aus und speichert sie in der Variablen len`f`b

`B100`F9d9feld.length = 5; // diese Zuweisung würde einen Fehler beim Kompilieren ergeben, da sie nicht zulässig ist`f`b

>>>>Mehrdimensionale Felder

Wie bereits angemerkt, kennt Java keine mehrdimensionalen Felder. Dennoch können Felder ineinander verschachtelt werden, um so eine analoge Struktur zu erhalten. Ein zweidimensionales Feld ist dabei mit einer Tabelle vergleichbar, wobei das erste (äußere) indizierende Feld auf die Zeile verweisen würde. Die Zeile selbst ist wiederum ein Feld, dessen Indizes auf die Spalte der Zeile, also auf den entsprechenden Eintrag, verweist, wie es auch in der Abbildung ersichtlich ist.

In Java können mehrdimensionale Felder durch die Angabe mehrerer eckiger Klammerpaare `B100`F9d9[]`f`b realisiert werden, wobei jedes Paar für eine weitere Dimension des Feldes steht. Das äußere Feld, welches das nächstinnere indiziert, steht dabei auf der linken Seite, bzw. ist das Klammerpaar, das als erstes definiert wurde. Dies ist am Beispiel eines Bildes ersichtlich, das üblicherweise mit `B100`F9d9[y][x]`f`b indiziert werden würde, wobei hier zunächst die Zeile (y) ermittelt wird und anschließend die Spalte (x) aus der Zeile.

`!Beispiel der Erstellung eines zweidimensionalen Feldes`!

`B100`F9d9double[][] feld = new double[zeilen][spalten];`f`b

Bei diesem Beispiel ist zu beachten, dass nicht nur das äußere Feld (hier `*feld`* genannt) allokiert wird, sondern auch die Felder für die „Zeilen“. Sie sind also nicht `*null`* und wurden ebenfalls mit angelegt. Ihre Einträge werden, wie von einem eindimensionalen Feld zu erwarten, mit `*0`* initialisiert.

In einer `F33f`_`[Matrix`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Matrix_(Mathematik)]`_`f werden die waagrechten Felder als Zeilen, die Senkrechten als Spalten bezeichnet. Ein einzelnes Element ist durch den jeweiligen Zeilen- und Spaltenindex eindeutig bestimmt. Die Syntax für eine Matrix oder allgemein für mehrdimensionale Felder ist fast identisch. Der Unterschied liegt in der Anzahl der geschlossenen eckigen Klammern, die Auskunft darüber geben, wie viele Dimensionen das Feld haben wird.

`!Beispiel der Erstellung eines zweidimensionalen Feldes mit unterschiedlichen Größen in den „Unterfeldern“`!

`B100`F9d9double[][] feld = new double[3][];`f`b

`B100`F9d9feld[0] = new double[3];`f`b

`B100`F9d9feld[1] = new double[2];`f`b

`B100`F9d9feld[2] = new double[1];`f`b

Bei diesem Beispiel ist zu beachten, dass im ersten Befehl nur das äußere Feld (hier `*feld`* genannt) allokiert wird und die einzelnen Elemente mit `*null`* initialisiert werden. In den folgenden Befehlen werden diesen Elementen dann die „Unterfelder“ zugewiesen, es ergibt sich hier ein „dreieckiges“ Feld.

Wie bei eindimensionalen Arrays gibt es auch bei mehrdimensionalen Arrays eine verkürzte Variante:

`B100`F9d9int[][] array2D={{1,2,3},{4,5,6}};`f`b

`B100`F9d9//Entspricht "=new int[2][3];" mit den darauf folgenden Zuweisungen`f`b

`B100`F9d9//"array2D[0][0]=1;"`f`b

`B100`F9d9//"array2D[0][1]=2;"`f`b

`B100`F9d9//(...)`f`b

`B100`F9d9//"array2D[1][2]=6;"`f`b

Wo die eckigen Klammern ([]) gesetzt werden, bleibt dem Programmierer überlassen:

`B100`F9d9int[][] A`f`b

ist das Gleiche wie

`B100`F9d9int A[][]`f`b

oder auch

`B100`F9d9int[] A[]`f`b

`!Allgemeine Syntax`!

`B100`F9d9<Datentyp> []… <Feldvariable> = new <Datentyp> [<Anzahl>]… ;`f`b

Die `F33f`_`[Auslassungspunkte`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Auslassungspunkte]`_`f ‘…’ stehen hier stellvertretend für weitere Klammerpaare, die jeweils eine weitere Dimension erzeugen. Der Zugriff auf die Elemente erfolgt analog zu denen eines eindimensionalen Feldes. Dabei ist jedoch zu beachten, dass auch auf das jeweilige äußere Feld zugegriffen werden kann, um z. B. die Anzahl der Zeilen zu bestimmen. Ausgehend vom Beispiel eines zweidimensionalen Feldes kann die Anzahl wie folgt bestimmt werden.

`!Auslesen und zuweisen von Werten`!

`B100`F9d9double wert = feld[y][x]; // liefert den Wert des Feldes x,y`f`b

`B100`F9d9feld[y][x] = wert; // weist dem Feld x,y einen Wert zu`f`b

`!Bestimmung der Länge des Feldes und der Unterfelder`!

`B100`F9d9int zeilenanzahl = feld.length; // weist der Variable "zeilenanzahl" den Wert von "feld.length" zu`f`b

Die Länge der Unterfelder kann über den Index des Feldes bestimmt werden.

`B100`F9d9int spaltenanzahl = feld[index].length; // weist der Variable "spaltenanzahl" den Wert von "feld[index].length" zu`f`b

In Langform, bzw. nach einzelnen Schritten aufgelöst, würde dies wie folgt aussehen. Daraus wird ebenfalls ersichtlich, dass es sich bei den Zeilen um Objekte – eindimensionale Felder – handelt.

`B100`F9d9double[] zeilenfeld = feld[index]; // ermittelt das erste "Unterfeld" mit gegebenen Index`f`b

`B100`F9d9int spaltenanzahl = zeilenfeld.length; // weist der Variable "spaltenanzahl" den Wert von "zeilenfeld.length" zu`f`b

>>>Anweisungen und Kontrollstrukturen

Java unterstützt die üblichen Anweisungen, die auch aus anderen imperativen Programmiersprachen bekannt sind. Einfache Anweisungen werden mit `F33f`_`[Semikolon`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Semikolon]`_`f abgeschlossen. Mehrere Anweisungen können mit geschweiften Klammern zu einem Anweisungsblock zusammengefasst werden. Kontrollstrukturen werden ebenfalls wie Blöcke behandelt und müssen (bis auf eine Ausnahme) daher nicht mit einem Semikolon abgeschlossen werden.

Als `F33f`_`[Kontrollstrukturen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kontrollstruktur]`_`f stehen die `*`F33f`_`[Bedingte Anweisung und Verzweigung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bedingte_Anweisung_und_Verzweigung]`_`f`* und `*`F33f`_`[Case-Anweisung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Case-Anweisung]`_`f`*, sowie die `*`F33f`_`[While`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=While-Schleife]`_`f`*-, `*`F33f`_`[Do-while`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Do-while-Schleife]`_`f`*- und `*`F33f`_`[For`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=For-Schleife]`_`f`*-Schleife und ihre verschiedenen Ausprägungen zur Verfügung.

>>>>Bedingte Anweisung und Verzweigung

Die `F33f`_`[Bedingte Anweisung und Verzweigung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bedingte_Anweisung_und_Verzweigung]`_`f, im Folgenden `*If-Anweisung`* genannt, ermöglicht es Anweisungen unter Voraussetzung einer bestimmten Bedingung ausführen zu lassen. Dazu wird das Schlüsselwort „if“ verwendet. Dahinter folgt ein Paar von runden Klammern, in dem die Bedingung definiert werden kann. Die Bedingung ist ein Ausdruck der als Ergebnis einen booleschen Wert (`*true`* oder `*false`*) liefern muss. Dies unterscheidet Java von anderen Sprachen wie etwa C, bei denen auch andere Werte als Bedingung erlaubt sind. Weiterhin ist anzumerken, dass das häufig anzutreffende Schlüsselwort „then“ nicht existiert.

Das Schlüsselwort „else“ kann verwendet werden um eine Anweisung im Falle des Nichtzutreffens der Bedingung auszuführen. Es ist optional und in diesem Fall spricht man von einer Verzweigung, da entweder die erste oder die zweite Anweisung ausgeführt wird. Alternativ kann anstatt „else“ ein „else if“ verwendet werden, das wie ersteres „if“ eine weitere Bedingung erwartet. Dadurch ist möglich Kaskaden von Verzweigungen aufzubauen. Ohne Strukturierung durch Blöcke (geschweifte Klammern) besteht jedoch die Gefahr eines `F33f`_`[Dangling else`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dangling_else]`_`f, bei dem nicht eindeutig ist, welcher If-Anweisung der Else-Zweig zuzuordnen ist.

`!Allgemeine Syntax`!

`B100`F9d9if (<Bedingung>)`f`b

`B100`F9d9 <Anweisung>;`f`b

`B100`F9d9else`f`b

`B100`F9d9 <Anweisung>;`f`b

`!Beispiel für eine einfache If-Anweisung mit einem Block von zwei Ausgaben`!

`B100`F9d9if (i < 0) {`f`b

`B100`F9d9 System.out.print("Die Zahl ist negativ"); // Bedingte Ausgabe`f`b

`B100`F9d9 System.out.println(); // Zeilenumbruch auf der Konsole`f`b

`B100`F9d9}`f`b

`!Komplexeres Beispiel`!

`B100`F9d9if (i < 0) {`f`b

`B100`F9d9 System.out.println("Die Zahl ist negativ");`f`b

`B100`F9d9}`f`b

`B100`F9d9else if (i == 0) {`f`b

`B100`F9d9 System.out.println("Die Zahl ist Null");`f`b

`B100`F9d9}`f`b

`B100`F9d9else if (i < 5) {`f`b

`B100`F9d9 System.out.println("Die Zahl ist kleiner als 5");`f`b

`B100`F9d9}`f`b

`B100`F9d9else {`f`b

`B100`F9d9 System.out.print("Die Zahl ist größer oder gleich 5");`f`b

`B100`F9d9}`f`b

>>>>Der Ternäre Operator

Für eine einfache If-Anweisung existiert eine zusätzliche Kurzschreibweise. Diese kann innerhalb eines Ausdrucks verwendet werden, ist aber auf ein „Entweder-oder“ beschränkt. D. h. sie muss in jedem Fall einen konkreten Wert zurückliefern. Der Operator selbst ist das Fragezeichen ‘?’ vor dem ein boolescher Ausdruck stehen muss. Hinter dem Fragezeichen folgt der Rückgabewert für den Fall, dass der boolesche Ausdruck wahr (true) ist. Anschließend folgt ein Doppelpunkt ‘:’ nach dem wiederum der Rückgabewert folgen muss, falls der boolesche Ausdruck nicht wahr (false) ist.

`!Syntax`!

`B100`F9d9<Bedingung> ? <Ausdruck> : <Ausdruck>`f`b

`!Beispiel`!

`B100`F9d9int a = (i<0) ? -i : i; // kehrt vor der Zuweisung an a das Vorzeichen von i um, wenn i negativ ist (Betrag von i)`f`b

>>>>Switch-Anweisung

• Eine Fallunterscheidung, wobei der Ausdruck ein Zeichen, eine Ganzzahl, eine Zeichenkette oder ein Aufzählungstyp sein kann.

`B100`F9d9switch (''Ausdruck'') {`f`b

`B100`F9d9 case ''Konstante1'': ''Anweisung1''; break;`f`b

`B100`F9d9 case ''Konstante2'': ''Anweisung2''; break;`f`b

`B100`F9d9 default: ''Anweisung3'';`f`b

`B100`F9d9}`f`b

>>>>Schleifen

Java unterscheidet vier verschiedene Arten von `F33f`_`[Schleifen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schleife_(Programmierung)]`_`f.

• Wiederhole eine Anweisung solange die Bedingung wahr ist, wobei die Bedingung vor der Anweisung geprüft wird (`F33f`_`[While-Schleife`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=While-Schleife]`_`f).

`B100`F9d9while (''Bedingung'') ''Anweisung'';`f`b

• Wiederholung einer Anweisung solange die Bedingung wahr ist, wobei die Bedingung erst nach der Ausführung geprüft wird (`F33f`_`[Do-while-Schleife`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Do-while-Schleife]`_`f).

`B100`F9d9do ''Anweisung''; while (''Bedingung'');`f`b

• Initialisiert einen Wert, wiederholt die Anweisung solange die Bedingung wahr ist und führt eine zweite Anweisung nach jedem Schleifendurchlauf aus (`F33f`_`[For-Schleife`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=For-Schleife]`_`f).

`B100`F9d9for (''Initialisierung''; ''Bedingung''; ''Anweisung2'') ''Anweisung1'';`f`b

• Zudem existiert eine erweiterte For-Schleife, auch Foreach-Schleife genannt, die es erlaubt, für jedes Element eines iterierbaren Objektes (`F33f`_`[Reihungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Feld_(Datentyp)]`_`f, `F33f`_`[Listen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Liste_(Datenstruktur)]`_`f etc.) Anweisungen auszuführen.

`B100`F9d9for (''Element'' : ''Kollektion'') ''Anweisung'';`f`b

Die nachfolgenden Beispiele zeigen den Einsatz einer solchen erweiterten For-Schleife, einmal angewendet auf den Basisdatentyp `F33f`_`[char`#primitive-datentypen]`_`f und einmal auf eine Liste.

`B100`F9d9char[] chars = new char[] { 'a', 'b', 'c' }; // neues Zeichen-Array anlegen`f`b

`B100`F9d9for (char c : chars) {`f`b

`B100`F9d9 System.out.println("Zeichen: " + c); // Jedes Zeichen auf die Konsole schreiben.`f`b

`B100`F9d9}`f`b

`B100`F9d9`f`b

`B100`F9d9List<Character> charlist = new ArrayList<Character>(); // neue Zeichen-Liste anlegen`f`b

`B100`F9d9charlist.add('a'); // Werte hinzufügen (mit Autoboxing)`f`b

`B100`F9d9charlist.add('b');`f`b

`B100`F9d9charlist.add('c');`f`b

`B100`F9d9for (Character c : charlist) {`f`b

`B100`F9d9 System.out.println("Zeichen: " + c); // Jedes Zeichen auf die Konsole schreiben.`f`b

`B100`F9d9}`f`b

>>>Ausdrücke

Im Gegensatz zu anderen Programmiersprachen, wie beispielsweise `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f, ist die Reihenfolge der Auswertung von Ausdrücken in Java bereits in der Sprachdefinition festgelegt: Binäre infix-Operatoren gleichen `F33f`_`[Rangs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Operatorrangfolge]`_`f, die keine Zuweisungsoperatoren sind, werden immer von links nach rechts ausgewertet. Außerdem gilt – wie in C auch – dass die Auswertung von logischen Ausdrücken verkürzt werden kann, wenn das Ergebnis bereits feststeht. Im folgenden Beispiel wird also garantiert zuerst überprüft, ob „`B100`F9d9objekt`f`b“ nicht „`B100`F9d9null`f`b“ ist. Ist dieser Teilausdruck `*false`* (also `B100`F9d9objekt`f`b ist eine Nullreferenz), wird der rechte Operand von `B100`F9d9&&`f`b gar nicht ausgewertet, d. h. die Methode `B100`F9d9inOrdnung()`f`b wird nicht gesucht oder gar gerufen. Somit ist der Gesamtausdruck sicher und kann niemals eine „`B100`F9d9NullPointerException`f`b“ verursachen. (Eine „`B100`F9d9NullPointerException`f`b“ wird in Java immer dann geworfen, wenn versucht wird, die Objektreferenz „`B100`F9d9null`f`b“ aufzulösen.)

`B100`F9d9if (objekt != null && objekt.inOrdnung()) {`f`b

`B100`F9d9 System.out.println("in Ordnung");`f`b

`B100`F9d9}`f`b

`B100`F9d9else {`f`b

`B100`F9d9 System.out.println("ungeprüft oder Prüfung misslungen");`f`b

`B100`F9d9}`f`b

Werden statt der logischen Operatoren `B100`F9d9&&`f`b und `B100`F9d9||`f`b die Bit-Operatoren `B100`F9d9&`f`b und `B100`F9d9|`f`b verwendet, so müssen beide Teilergebnisse bitweise verknüpft werden und die Verarbeitung kann nicht beim linken Ausdruck abbrechen, falls der `B100`F9d9false`f`b ist. Hat also die Variable `B100`F9d9objekt`f`b den Wert `B100`F9d9null`f`b, so versucht die Java-VM, den aus dem ersten Ausdruck resultierenden Wert `B100`F9d9false`f`b mit dem Ergebnis des zweiten Ausdrucks bitweise zu verknüpfen. Um den zweiten Ausdruck zu berechnen, versucht die VM `B100`F9d9objekt`f`b zu dereferenzieren und wirft eine `B100`F9d9NullPointerException`f`b.

>>>>Funktionale Schnittstellen und Lambda-Ausdrücke

Ein Lambda-Ausdruck ist eine namenlose (anonyme) Methode, die (als Objekt) weitergegeben werden kann. Lambda-Ausdrücke beschreiben also Funktionsobjekte. Der Begriff geht auf den `F33f`_`[Lambda-Kalkül`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lambda-Kalkül]`_`f zurück, eine `F33f`_`[formale Sprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Formale_Sprache]`_`f zur Untersuchung von `F33f`_`[Funktionen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_(Mathematik)]`_`f (siehe auch `F33f`_`[funktionale Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktionale_Programmierung]`_`f). Lambda-Ausdrücke in Java gibt es seit Java 8 und umfassen Parameterlisten, einen Rückgabetyp und einen Body:

`B100`F9d9(<Datentyp> <Variablenbezeichner>,...,<Datentyp> <Variablenbezeichner>) -> <Anweisungsblock>`f`b

`B100`F9d9(<Datentyp> <Variablenbezeichner>,...,<Datentyp> <Variablenbezeichner>) -> <Ausdruck>`f`b

`B100`F9d9(<Variablenbezeichner>,...,<Variablenbezeichner>) -> <Anweisungsblock>`f`b

`B100`F9d9(<Variablenbezeichner>,...,<Variablenbezeichner>) -> <Ausdruck>`f`b

Die runden Klammern können weggelassen werden, wenn die Anzahl der enthaltenen Elemente genau eins ist. Die Angabe der Parametertypen ist nur dann erforderlich, wenn der Compiler sie nicht selbst aus dem Kontext des Ausdrucks ableiten kann.`:cite-ref-5[`F5bf`_`[3`#cite-note-5]`_`f] Eine Funktion, die die Summe von zwei Argumenten liefert, lässt sich folgendermaßen ausdrücken:

`B100`F9d9(i,j) -> i+j`f`b

Sie haben selbst keinen konkreten Typ und können daher nur in einem Kontext verwendet werden, der einen Typ vorgibt, etwa Methodenaufrufe, Return-Anweisungen und Variableninitialisierungen. Der vorgegebene Typ muss eine funktionale Schnittstelle sein. In folgendem Beispiel ist ein `B100`F9d9Comparator<String>`f`b-Objekt mit Hilfe eines Lambda-Ausdrucks definiert. Der `B100`F9d9sort`f`b-Aufruf bewirkt die Sortierung von `B100`F9d9someStrings`f`b nach deren Länge, in absteigender Reihenfolge.

`B100`F9d9List<String> someStrings = ...`f`b

`B100`F9d9Collections.sort(someStrings, (x,y) -> y.length() - x.length());`f`b

Lambda-Ausdrücke helfen, die oft schlecht lesbaren, langen Deklarationen innerer, anonymer Klassen, zu vermeiden.

In Java heißen Schnittstellen, die nur über eine Operation (abstrakte Methode) verfügen, `*funktionale Schnittstellen`*. Eine abstrakte Klasse mit genau einer abstrakten Methode zählt allerdings `*nicht`* als funktionale Schnittstelle.

Methodenreferenzen stellen ebenfalls eine ab Java 8 verfügbare Möglichkeit dar, funktionale Schnittstellen zu implementieren. Sie haben eine der Formen

`B100`F9d9<Klassenreferenz>::<Methodenbezeichner>`f`b

`B100`F9d9<Ausdruck>::<Methodenbezeichner>`f`b

In folgendem Code wird die Methodenreferenz `B100`F9d9System.out::println`f`b als ein `B100`F9d9java.util.function.Consumer<String>`f`b-Objekt verwendet.

`B100`F9d9static <A> Consumer<A> doTwice(Consumer<A> consumer) {`f`b

`B100`F9d9 return a -> {`f`b

`B100`F9d9 consumer.accept(a);`f`b

`B100`F9d9 };`f`b

`B100`F9d9}`f`b

`B100`F9d9static void foo() {`f`b

`B100`F9d9 doTwice(System.out::println).accept("Hello");`f`b

`B100`F9d9}`f`b

>>>Kommentare

`F33f`_`[Kommentare`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kommentar_(Programmierung)]`_`f sind Teile des Quellcodes, welche Informationen für den menschlichen Leser enthalten und vom Computer bei der Weiterverarbeitung ignoriert werden.

Man unterscheidet zwischen Zeilenkommentare und Blockkommentare. Der Zeilenkommentar folgt an einer Zeile. Die Syntax besteht aus einem Doppelschrägstrich. Der Blockkommentar umfasst die Beschreibung mehrerer Zeilen. Die Syntax dafür besteht aus einem Schrägstrich und darauf folgendes Mal-Zeichen. Mit dem Mal-Zeichen und dem Schrägstrich wird der Kommentar geschlossen. Beim Kompilieren werden die Kommentare vom Compiler ignoriert.

Beispiel:

`B100`F9d9 int i = 10; // Zeilenkommentar: hier bekommt die Variable i den Wert 10 zugewiesen.`f`b

`B100`F9d9 int j = 0;`f`b

`B100`F9d9`f`b

`B100`F9d9/* Blockkommentar: hier beginnt eine While-Schleife`f`b

`B100`F9d9....`f`b

`B100`F9d9j wird um Eins erhöht, solange j kleiner i ist.*/`f`b

`B100`F9d9 while (j < i) {`f`b

`B100`F9d9 j++;`f`b

`B100`F9d9 }`f`b

Zur Dokumentation ganzer Methoden oder Klassen wird oft das `F33f`_`[Javadoc`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Javadoc]`_`f-System verwendet.

>>>Generische Programmierung

→

Hauptartikel

Generische Programmierung in Java

Mit Version 5 von Java wurde das Sprachmittel der generischen Programmierung eingeführt.

>>Einzelnachweise

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f Scott Stanchfield: `*Java is Pass-by-Value, Dammit!`* JavaDude.com, abgerufen am 5. November 2010 (englisch).

`:cite-note-sun-reference-value-2`!2.`! `F0af`_`[↑`#cite-ref-sun-reference-value-2-0]`_`f `*Types, Values, and Variables.`* In: `*Java Language Specification.`* Oracle (Sun), archiviert vom Original (nicht mehr online verfügbar) am 9. März 2012; abgerufen am 6. November 2010 (englisch).

`:cite-note-5`!3.`! `F0af`_`[↑`#cite-ref-5]`_`f Martin Gerlach: Java SE 8 Neuerungen (Teil 1): Lambda-Ausdrücke und Default-Methoden In: Neo Tech Blog (erstellt am 17. November 2014, abgerufen am 16. Dezember 2016).

`c`F0af`_`[↑ Back to top`#top]`_`f`a